#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("inline")
#include <iostream>
#include <unordered_map>
#include <map>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;

struct Server{
    int id;  // 服务器编号
    string type;  // 服务器型号
    int cpu;  // 总的cpu
    int mem;  // 总的内存
    int cpu_A, cpu_B;  // A B 节点cpu剩余量
    int mem_A, mem_B;  // A B 节点内存剩余量
    int hardware_cost;  // 硬件花费
    int day_cost;  // 每日能耗花费
    unordered_map<int, int> vms_id;  // 存放部署在该服务器上的虚拟机id
};

struct VM{
    int id;  // 虚拟机ID
    string type;  // 虚拟机型号
    int cpu;
    int mem;
    bool isTwoNodes;  // 是否双节点部署
    int serverID;  // 该虚拟机所部署服务器的ID
    int assign_node;  // 该虚拟机安装在服务器的A节点则为1，B节点则为2
};

struct Query{
    string type;  // 请求类型：add 或 del
    string vm_type;  // 创建时虚拟机类型
    int vm_id;  // 虚拟机ID
};
vector<vector<Query>> query;  // 存放每天的请求

class ServerManager{
public:
    vector<Server> servers;  // 存放所有的服务器
    unordered_map<int, Server> ID2Server;  // 建立ID到服务器的索引
    unordered_map<string, Server> type2Server;  // 建立类型到服务器的索引
    unordered_map<string, int> num;  // 存放当前每种类型的服务器数目
    int serverID = -1;  // 建立服务器ID，每次新增服务器则此ID加1
    bool isEmpty(Server &server);  // 查看当前服务器是否为空
    long long getEnergyCost();  // 计算当前开机的服务器一天的能耗
    long long getHardwareCost();  // 计算当前买服务器的花费
};

class VmManager{
public:
    int num;  // 当前存活的虚拟机数目
    unordered_map<string, VM> type2VM;  // 建立类型到虚拟机的索引
    unordered_map<int, VM> ID2VM;  // 建立ID到虚拟机的索引
    int getMigrationNum();  // 获取可以的迁移次数
};

// 方法申明区
vector<Query> reorderQuery(vector<Query> &vector);
bool query_cmp(const Query &q1, const Query &q2);
bool canAssign(Server &server, VM &vm, int node);
int getFitness(Server &server, VM &vm, int node);
void doAssign(Server &server, VM &vm, int node);

// 服务器和虚拟机的管理对象
ServerManager serverManager;
VmManager vmManager;

void read_data()
{
    // 读取服务器数据
    int N; cin >> N;
    for(int i = 0; i < N; i ++ ){
        Server server;
        string type; cin >> type;
        type = type.substr(1), type.pop_back();  // 去除行首括号和多余的逗号
        server.type = type;

        string cpu; cin >> cpu;
        cpu.pop_back();
        server.cpu = stoi(cpu);
        server.cpu_A = server.cpu / 2;
        server.cpu_B = server.cpu / 2;

        string mem; cin >> mem;
        mem.pop_back();
        server.mem = stoi(mem);
        server.mem_A = server.mem / 2;
        server.mem_B = server.mem / 2;

        string cost; cin >> cost;
        cost.pop_back();
        server.hardware_cost = stoi(cost);

        cin >> cost;
        cost.pop_back();
        server.day_cost = stoi(cost);
        server.vms_id.clear();
        serverManager.type2Server[server.type] = server;
        serverManager.servers.push_back(server);
    }

    // 读取虚拟机数据
    int M; cin >> M;
    for(int i = 0; i < M; i ++ ){
        VM vm;
        string type; cin >> type;
        type = type.substr(1), type.pop_back();
        vm.type = type;

        string cpu; cin >> cpu;
        cpu.pop_back();
        vm.cpu = stoi(cpu);

        string mem; cin >> mem;
        mem.pop_back();
        vm.mem = stoi(mem);

        string flag; cin >> flag;
        flag.pop_back();
        vm.isTwoNodes = stoi(flag);
        if(vm.isTwoNodes){  // 双节点/2
            vm.cpu /= 2;
            vm.mem /= 2;
        }
        vm.serverID = -2;
        vmManager.type2VM[vm.type] = vm;
    }

    // 处理请求数据
    int T; cin >> T;
    for(int i = 1; i <= T; i ++ ){
        vector<Query> dayQuery;  // 存放一天的请求
        int R; cin >> R;
        for(int j = 0; j < R; j ++ ){
            Query q;
            string type; cin >> type;
            type = type.substr(1), type.pop_back();
            q.type = type;

            if(q.type == "add"){
                string vm_type; cin >> vm_type;
                vm_type.pop_back();
                q.vm_type = vm_type;
            }

            string id; cin >> id;
            id.pop_back();
            q.vm_id = stoi(id);
            if(q.type == "add"){
                VM &vm = vmManager.type2VM[q.vm_type];
                vm.id = q.vm_id;
                vmManager.ID2VM[q.vm_id] = vm;
            }
            dayQuery.push_back(q);
        }
        query.push_back(dayQuery);
    }
}

int main() {
    ios::sync_with_stdio(false);
    freopen("../training-1.txt", "r", stdin);
    long long hardware_cost = 0, day_cost = 0;
    // 读取数据
    read_data();

    for(auto &dayQuery: query) {
        vector<Query> temp = reorderQuery(dayQuery);  // 重新排序今天的请求
        // TODO 内部处理逻辑
        for(auto &q: temp){
            // 取出对应的虚拟机ID
            VM &vm = vmManager.ID2VM[q.vm_id];
            cout << q.type << " " << vm.mem + vm.cpu << endl;
        }
    }

    cout << "hardware_cost: " << hardware_cost << ", energy_cost: " << day_cost << endl;
    cout << "total cost: " << hardware_cost + day_cost << endl;
    return 0;
}


void doAssign(Server &server, VM &vm, int node) {
    // 将虚拟机vm部署到服务器server后的操作，如果node=0表示双节点部署，node=1表示部署到A节点，node=2表示部署到B节点
    server.vms_id[vm.id] = 1;
    vm.serverID = server.id;
    vm.assign_node = node;
    if(node == 0){
        server.cpu_A -= vm.cpu, server.mem_A -= vm.mem;
        server.cpu_B -= vm.cpu, server.mem_B -= vm.mem;
    }else if(node == 1){
        server.cpu_A -= vm.cpu, server.mem_A -= vm.mem;
    }else{
        server.cpu_B -= vm.cpu, server.mem_B -= vm.mem;
    }
}

int getFitness(Server &server, VM &vm, int node) {
    // 获得虚拟机和服务器server的合适程度，d1,d2越大表示差距越大，对其取负值表示d1,d2越大则契合度越高
    int d1 = server.cpu_A - vm.cpu + server.mem_A - vm.mem;
    int d2 = server.cpu_B - vm.cpu + server.mem_B - vm.mem;
    if(node == 0) return - d1 - d2;
    else if(node == 1) return - d1;
    else return - d2;
}

bool canAssign(Server &server, VM &vm, int node) {
    if(node == 0){  // 能否双节点部署
        return server.cpu_A >= vm.cpu && server.mem_A >= vm.mem
               && server.cpu_B >= vm.cpu && server.mem_B >= vm.mem;
    }else if(node == 1){  // 能否部署在A节点
        return server.cpu_A >= vm.cpu && server.mem_A >= vm.mem;
    }else{  // 能否部署在B节点
        return server.cpu_B >= vm.cpu && server.mem_B >= vm.mem;
    }
}

vector<Query> reorderQuery(vector<Query> &dayQuery) {
    vector<vector<Query>> list;
    vector<Query> temp;
    for(auto &q: dayQuery){
        if(!temp.empty() && q.type != temp.back().type){
            list.push_back(temp);
            temp.clear();
        }
        temp.push_back(q);
    }
    if(!temp.empty()) list.push_back(temp);
    // 对list中每个部分重排序
    for(auto &item: list){
        if(item.back().type == "del") continue;
        // 将每一块"add"区指令按照对应虚拟机cpu+mem大小从大到小排序
        sort(item.begin(), item.end(), query_cmp);
    }

    temp.clear();
    for(auto &item: list){
        for(auto &q: item){
            temp.push_back(q);
        }
    }
    return temp;
}
bool query_cmp(const Query &q1, const Query &q2){
    VM &v1 = vmManager.ID2VM[q1.vm_id], &v2 = vmManager.ID2VM[q2.vm_id];
    return v1.cpu + v1.mem > v2.cpu + v2.mem;
}
bool ServerManager::isEmpty(Server &server) {
    // 判断某个服务器是否为空
    if(server.cpu_A + server.cpu_B == server.cpu && server.mem_A + server.mem_B == server.mem){
        return true;
    }
    return false;
}

long long ServerManager::getEnergyCost() {
    // 计算当前在使用服务器本日的花费，每天计算
    long long cost = 0;
    for(auto &it: ID2Server){
        auto &server = it.second;
        if(!isEmpty(server)) cost += server.day_cost;
    }
    return cost;
}

long long ServerManager::getHardwareCost() {
    // 计算服务器的购买成本，程序最后计算即可
    long long cost = 0;
    for(auto &it: ID2Server){
        auto &server = it.second;
        cost += server.hardware_cost;
    }
    return cost;
}

int VmManager::getMigrationNum() {
    int cnt = num * 5 / 1000;
    return cnt;
}